Após o término da aula você terá aprendido:
Se você já conhece a linguagem e está animado em aprendê-la já pode seguir para a próxima seção. Se, mesmo assim, você ainda estiver curioso para saber mais sobre Python fique convidado a ler os próximos parágrafos.
Python é uma linguagem simples, enxuta e poderosa. Com poucas linhas e sintaxe clara é possível executar tarefas complexas. Essa característica se dá, pois os tipos de dados de alto nível permitem fazer operações complexas de uma única vez, além de não ser necessário declarar variáveis ou tipos dos argumentos.
Python vem com pilhas inclusas. Em sua biblioteca padrão há soluções para diversos tipos de problemas recorrentes, como:
A linguagem foi criada em 1991 e desde então vem crescendo constantemente ano a ano, tanto no quesito de número de usuário quanto em atualizações e melhorias do interpretador e da linguagem em si. Atualmente Python está na versão 3.5 que trouxe várias features interessantes que podem ser conferidas aqui.
Muitas empresas como Google, Facebook, Mozilla, Microsoft, Intel, IBM, Globo e Magazine Luiza usam Python em produtos como Instagram, YouTube e o g1 (portal de notícias da globo).
PS: Dica para vida: os patrocinadores de grandes eventos como, por exemplo PyCon 2015 e 2016, usam e estão patrocinando a linguagem. E isso também vale para qualquer outra tecnlogia.
Python é uma linguagem interpretada, ou seja, seu código-fonte executado diretamente pelo interpretador, sem precisar de compilar o programa em instruções de linguagem de máquina.
PS: para agilizar a execução de módulos o interpretador do Python cria caches. Para saber mais, veja: “Compiled” Python files
Por ser interpretada a Python ganha diversas vantagens, como:
A linguagem possui 20 príncipios que guiam seu desenvolvimento e podem ser conferidos rodando o seguinte comando:
In [1]:
import this
Agora é hora de por as mãos na massa! Vamos do começo:
Caso você já tenha o Python 3.5 siga para a próxima sessão!
$ sudo apt-get install python3.5
https://www.python.org/downloads/
Caso você esteja usando o windows não esqueça de marcar a opção: "Add Python.exe to Path", como mostrado na seguinte imagem:
O virtualenv é uma ferramenta que serve para manter as dependências de projetos diferentes em pastas separadas, desse modo é possível trabalhar me um projeto usando, por exemplo, o Django 1.9 enquanto se mantém um projeto antigo que usa a versão 1.5 do framework.
O virtualenv cria uma pasta contendo todas as dependências que um projeto Python necessita.
O virtualenv já vem instalado no Python 3.5, para criar um novo ambiente faça:
$ python3.5 -m venv env
Abra o programa de linha de comando do Windows e digite o comando abaixo. Isso pode ser feito apertando o botão do windows + R, digitando cmd e apertando ENTER.
> C:\Python3.5\python -m venv env
Esse comando criará uma pasta chamada env/ contendo os executáveis do Python e uma cópia do pip para instalar outros pacotes. Vale lembrar que o nome do ambiente virtual env pode ser trocado por qualquer outro.
Para usar o virtualenv é necessário antes que ele seja ativado:
$ source env/bin/activate
> env\Scripts\activate
Para sair de um ambiente virtual use o comando deactivate.
Agora nosso ambiente virtual está pronto para ser usado!
O pip permite instalar pacotes Python (listados no PyPI: the Python Package Index) de forma fácil. O pip significa "pip install packages" (ou pip instala pacotes).
Por exemplo, vamos instalar a biblioteca requests que usaremos mais para frente nesta aula:
(env) $ pip install requests
O Jupyter Notebook é uma aplicação web que permite a criação e compatilhamento de documentos (notebooks) que contém código ao vivo, equações, visualizações e textos explanatórios. Ele é muito utilizado para transformação de dados, modelagem estatística, simulação numérica, aprendizado de máquina e ensino.
Para rodá-lo em sua máquina é preciso: instalar, rodar o servidor e acessr pelo navegador! É mais simples do que parece, vamos fazer esses passos.
Vamos instalar o jupyter notebook executando o seguinte comando:
(env) $ pip install jupyter[notebook]
Caso não seja possível instalar o jupyter[notebook] rode:
$ sudo apt-get install build-essential python3.5-dev
(env) $ pip install --upgrade pip
(env) $ pip install jupyter[notebook]Não esqueça de baixar este documento (Aula01.ipynb) e rodar o jupyter notebook na mesma pasta.
Para rodá-lo e tornar possivel o acesso do notebook pelo navegador, execute o seguinte comando:
(env) $ jupyter notebook
Agora é só acessar a página http://localhost:8888/notebooks (que deve ter sido aberta automaticamente) e abrir o notebook Aula01.ipynb que já estamos prontos para codificar!
Para rodar um código específico clique na caixa do código e pressione CTRL+Enter
Nosso primeiro exemplo será criar o código de uma aplicação que nos permite baixar o código-fonte de sites.
Para isso vamos usar a biblioteca requests que foi instalada em um passo anterior (caso você não tenha instalado rode pip install requests).
Primeiro preciamos importar a requests:
In [1]:
import requests
Agora vamos fazer uma requisição HTTP ao Github para baixar o conteúdo do repositório deste curso (através da URL https://github.com/lamenezes/python-intro):
In [2]:
url = 'https://github.com/lamenezes/python-intro' # não é necessário declarar variáveis em python
response = requests.get(url) # e nem especificar seu tipo
response.status_code
Out[2]:
200 é o código de resposta que informa que a requisição foi bem sucedida (ou OK).
PS: No curso de Desenvolvimento Web com Django será explicado com calma como funciona o protocolo HTTP.
Agora vamos analisar os cabeçalhos dessa resposta:
In [3]:
print(response.headers)
O atributo headers de response (response.headers) nos trouxe os cabeçalhos em forma de um dicionário (ou dict). O dict é uma estrutura de dados do Python utilizada para armazenar informações na forma de chave e valor envoltas por chaves {}. Dicts serão explicados mais para frente.
Por motivos técnicos a saída foi apresentada em um formato difícil de ler, para melhorá-la podemos fazer um pequeno workaround:
In [4]:
dict(response.headers)
Out[4]:
Para acessar um cabeçalho específico por sua chave fazemos:
In [5]:
response.headers['content-type']
Out[5]:
In [6]:
response.headers['date']
Out[6]:
In [7]:
response.text[:1000] # retorna os 1000 primeiros caracteres do conteúdo da resposta
Out[7]:
Como visto anteriormente a biblioteca requests permite o envio de requisições HTTP de maneira extremamante fácil. Para obter mais informações sobre a requests acesse a doumentação oficial.
Agora que já aprendemos o básico podemos partir para um exemplo mais interessante.
O Github oferece uma API que fornece dados de seus repositórios públicos. São dadas informações como quantos projetos estão cadastrados na plataforma, quantos contribuidores trabalharam em quais repositórios, a quais organizações essas fazem parte e muito mais. (mais informações na documentação oficial)
O acesso aos dados dessa API é feito através do envio de requisições HTTP para diferentes caminhos na URL base https://api.github.com/. Caso você queira testar a API, pode acessar o link anterior pelo navegador e mudar a URL manualmente, porém nosso foco aqui será usar a biblioteca requests para pegar esses dados.
Todas as respostas da API são em formato JSON. O JSON siginifca JavaScript Object Notation e pronuncia-se "djêizon" e é um formato fácil de processar e simples de utilizar. Para mais informações sobre o JSON acesse a página oficial. Falaremos mais sobre JSON no decorrer do curso, mas fique tranquilo que não segredo há algum nesse assunto.
Vamos testar a API e pegar os repositórios de um usuário específico através da URL https://api.github.com/users/lamenezes/repos:
In [8]:
response = requests.get('https://api.github.com/users/lamenezes/repos')
response.status_code
Out[8]:
In [9]:
response.text[:1000] # pegando os primeiros 1000 caracters do conteúdo da resposta
Out[9]:
A resposta trouxe todos os repositórios do usuário lamenezes em uma string no padrão JSON.
Essa string não é interessante para nós, pois é difícil acessar dados específicos do JSON através dela. Seria muito melhor para nós se essa resposta fosse traduzida para um dicionário do Python (que possui sintaxe muito parecida com o JSON).
Normalmente teríamos que importar a biblioteca json e realizar a conversão, no pior caso poderia ser necessário escrever um parser específico para tratar casos especiais.
No entanto, a biblioteca requests já faz esse trabalho para nós:
In [10]:
repositorios = response.json()
repo = repositorios[0] # pegando apenas o primeiro repositório por brevidade
repo
Out[10]:
A resposta nos trouxe uma lista de dicionários com as informações dos repositórios do usuário lamenezes. Agora fica a dúvida: o que exatamente é uma lista e um dicionário?
Listas, como o próprio nome sugere, são estruturas de dados mutáveis que armanzenam listas de valores. Os valores da lista são acessados pelo número relativo a sua posição.
Ao invés de gastar dedos digitando mais sobre o que é uma lista é mais fácil demonstrá-la:
In [11]:
numeros = [1, 2.5, 3, 4.5, 5]
numeros
Out[11]:
In [12]:
numeros[0]
Out[12]:
In [13]:
numeros[3]
Out[13]:
In [14]:
numeros[-1] # -1 acessa o último elemento da lista!
Out[14]:
Listas podem armazenar qualquer tipo de dados:
In [15]:
lista = ['foobar', False, ['a', 'b', 'c'], {'foo': 'bar'}, 10, -0.5]
lista
Out[15]:
Fazemos assim para verificar se um elemento faz parte de uma lista:
In [16]:
'foobar' in lista
Out[16]:
In [17]:
'abc' in lista
Out[17]:
In [18]:
-0.5 in lista
Out[18]:
Para saber o tamanho de uma lista basta usar a função len():
In [19]:
len(lista)
Out[19]:
In [20]:
len(lista[2]) # o segundo elemento da lista é uma lista com 3 elementos!
Out[20]:
In [21]:
len(numeros)
Out[21]:
Para remover elementos de uma lista existe a palavra reservada del que é utilizada assim:
In [22]:
lista
Out[22]:
In [23]:
del lista[3]
lista
Out[23]:
In [24]:
del lista[-1] # remove último elemento
lista
Out[24]:
Iterar uma lista é simples:
In [25]:
for numero in numeros:
print(numero)
O for do Python, diferentemente de outras linguagens como C e Java, faz o controle dos índices internamente.
Vamos fazer mais um exemplo para deixar claro:
In [26]:
numeros = range(1, 11) # cria uma lista de números de 1 a 10
list(numeros)
Out[26]:
In [27]:
for numero in numeros:
print(numero ** 2) # numero elevado a segunda potência
A função range(inicio, fim) cria listas de valores no intervalo de inicio até fim - 1. Ao lidar com intervalos no python o primeiro número é sempre incluso e o último excluído. Segue alguns exemplos de uso da função range()
In [28]:
list(range(10)) # números de 0 a 9
Out[28]:
In [29]:
list(range(10, 20)) # números de 10 a 19
Out[29]:
In [30]:
list(range(10, 21)) # números de 10 a 20
Out[30]:
In [ ]:
from math import pi
numeros = ... # crie a lista de números de 2 a 8
for numero in numeros:
print( ... ) # imprime o número vezes pi
In [ ]:
taxa_dolar = 3.53 # mude esse valor caso o valor do dólar tenha mudado
preços = ... # python 3 permite declarar variáveis com acentos
for preço in preço:
print(...)
Dicionários são estruturas de dados utilizadas para armazenar conjuntos de chaves e valores. Em algumas linguagens também são conhecidos como mapaemento.
A diferança de uso entre lista e dicionáro é que o último é acessado por chaves e não pela posição. As chaves podem ser inteiros, strings, booleanos e tuplas (este será visto na próxima aula).
A seguir temos alguns simples exemplos de uso de diconários.
Criar um dict é simples:
In [32]:
notas = {'joao': 5, 'maria': 9, 'ana': 7}
notas
Out[32]:
Para acessar os elementos basta usar sua chave:
In [33]:
notas['ana']
Out[33]:
In [34]:
notas['joao']
Out[34]:
Para alterar algum valor fazemos:
In [35]:
notas['joao'] = 6.5
notas
Out[35]:
In [36]:
notas['ana'] = 7.5
notas
Out[36]:
Verificamos se uma chave existe no dicionário da seguinte maneira:
In [37]:
'joao' in notas # verifica se o valor é uma chave do dicionário
Out[37]:
In [38]:
'joana' in notas
Out[38]:
In [39]:
'ana' in notas
Out[39]:
Para acessar somente as chaves fazemos:
In [40]:
list(notas.keys())
Out[40]:
Para acessar somente os valores:
In [41]:
list(notas.values())
Out[41]:
Para ter uma lista contendo as chaves e valores:
In [42]:
list(notas.items())
Out[42]:
Para iterar dicionáros é preciso ter cuidado. Por padrão as chaves do dicionário são iteradas:
In [43]:
for chave in notas:
print(chave)
Caso você queira imprimir os valores é preciso usar notas.values():
In [44]:
for valor in notas.values():
print(valor)
Para iterar tanto a chave quanto o valor use a função notas.items() como mostrado a seguir:
In [45]:
for chave, valor in notas.items():
print(chave, valor)
Para ficar mais claro podemos mudar os nomes das variáveis e para ficar mais inteligível formatar a saída:
In [46]:
for nome, nota in notas.items():
print('{0} tirou {1}.'.format(nome.capitalize(), nota))
In [47]:
list(notas.items())
Out[47]:
Como visto acima o notas.items() retorna uma lista de chaves e valores. Por esse motivo a cada iteração temos acesso a cada chave e valor do dicionário notas, tornando possível essa iteração mais simples e semântica.
Agora que já temos uma noção das estruturas de dados utilizadas, podemos continuar a visualizar as informações dos repositórios do github:
PS: relaxe, pois nas próximas aulas veremos a fundo essas estruturas!
Anteriormente realizamos uma requisição à API do github para pegar os repositórios do usuário lamenezes e armazenamos a resposta na variável response. Essa variável ainda está disponível para nós, o que nos permite continuar nosso exemplo anterior:
In [48]:
repositorios = response.json() # lista de dicionários com dados de cada repositório
repo = repositorios[11] # vamos analisar o décimo primeiro repositório
repo
Out[48]:
In [49]:
repo['full_name']
Out[49]:
In [50]:
repo['description']
Out[50]:
In [51]:
repo['created_at'] # data de criação
Out[51]:
In [52]:
repo['html_url'] # URL da página principal do repositório
Out[52]:
Também temos os dados do dono (owner) do repositório:
In [53]:
dono = repo['owner']
dono['login']
Out[53]:
'owner' é um dicionário dentro do dicionário do repositório (sim, é possível guardar dicionários dentro de dicionários)
Também podemos acessar as informações diretamente sem recorrer à variável intermediária dono:
In [54]:
repo['owner']['login']
Out[54]:
In [ ]:
# digite o código aqui
In [ ]:
# digite o código aqui
Para os próximos exercícios será necessáro pegar os repositórios do usuário gvanrossum. Use a biblioteca requests e faça uma requição à API do github (https://api.github.com/) como demostrado anteriormente.
In [ ]:
response = ...
response.status_code # status_code deve ser 200
Agora pegue o conteúdo da resposta em formato JSON e atribua à variável repos:
In [ ]:
repos = ...
len(repos) # esta linha deve retornar 5
gvanrossum:
In [4]:
import requests
response = requests.get('https://api.github.com/users/gvanrossum/repos')
repositorios = response.json()
for repositorio in repositorios:
print(repositorio['full_name'], repositorio['description'])
In [ ]:
# digite o código aqui
In [ ]:
# digite o código aqui
Última pergunta:
gvanrossum?